feat(snapshot): add cow memory and resident pause lifecycle - #1537

Let capture borrow an executor-owned pause generation and workload latch,
validate the execution boundary, and leave that source paused on success
or failure. Keep the existing running-source call path unchanged.

Public pause ownership is not wired yet: agent freezer capability and
partial-failure replies must be disambiguated before basic-pause fallback
can be exposed safely. Existing checkpoint tests and runtime checks pass;
the borrowed-pause path still needs end-to-end qualification.

Record latch ownership before freezer writes and retain it after failed
freeze or thaw acknowledgement. Only confirmed thaw releases the latch.

Add optional attempt-scoped error details without a protocol generation
bump. Treat older ambiguous errors and transport failures as requiring
recovery, and fence mutations if acknowledged recovery fails.

Cover failure injection, retry ownership, protocol compatibility, and
host recovery disposition. Public pause/resume wiring remains pending.

Wire explicit memory policy and pause/resume through the CLI and Rust,
Python, Node, and Go SDKs. Preserve user pause ownership across full
captures and correct the guest clock before releasing workloads.

Restore from pinned immutable memory caches and prepare repeated capture
caches from immutable generations, reusing filesystem reflinks where
available. Resolve control endpoints and cache paths through the owning
local backend, and pin the matching runtime and firmware companions.

Add live lifecycle smoke matrices and record Linux/macOS results and
remaining qualification gaps. Windows CoW remains unsupported; private
zeroing on unplug does not yet reclaim host RAM. This commit does not
claim full stack-8 qualification.

Extend the live lifecycle runner with optional memory resizing,
unsupported CoW admission checks, archive retention diagnostics, and
explicit timeout evidence. Assert retained child contents after archive
removal and source shutdown.

Record passing Linux capacity convergence and Windows post-restore
command timeouts without treating activation latency as usable restore
performance. Keep incomplete qualification and implementation work
explicit in the report.

Avoid repeated closure validation and disposable staging syncs while retaining payload admission, persistent disk durability and guest activation ordering. Serialize CoW cache misses without serializing warm hits.

Preserve sparse archive members with long names, buffer archive extraction, and merge incremental memory extents with a consuming sweep. Resolve flat snapshot image metadata without materializing unused OCI disks and allow those sandboxes to restart without a VMDK.

Add correctness regression coverage and record release-build macOS benchmarks, old/new archive reader checks, empty-cache restoration, concurrent CoW restores and child isolation tests.

Create independent local children through the existing capture and restore paths without publishing a durable full snapshot. Reuse immutable RAM generations with reflinks and dirty ranges, and protect handoff and VM backing lifetimes with independent pins.

Expose branching across the CLI and Rust, Python, TypeScript and Go SDKs. Replace the unreleased memory-snapshot creation policy with restore-only forked selection, and reject unsupported or incomplete restore requests instead of falling back to a fresh boot.

Update documentation and add macOS live lifecycle, isolation, ownership and release benchmark harnesses. macOS release and SDK qualification passed; Linux and Windows qualification remains outstanding.

Enable Windows private RAM backing with protected cache entries and
cross-platform lifetime pins. Persist pending restore intent until
creation succeeds so failed children cannot cold-boot or mutate sealed
snapshot layers through later lifecycle operations.

Pin the published native memory and ARM64 interrupt/barrier fixes.
Add failed-restore and retained-sibling timer regressions, port ownership
checks to Windows, and document the four-host live qualification results.

Expose disk-only capture for running and user-paused managed and flat
sandboxes through the existing snapshot CLI and shared SDK paths.
Serialize root rollover in runtime control without capturing RAM or
advancing its baseline, preserve user pauses, and capability-gate older
runtimes. Keep stopped lifecycle locking and direct archive publication.

Update API documentation and record live flat/layered coverage on macOS
ARM64, Linux x86-64, and Windows ARM64, including active writes, source
isolation, direct archives, and mixed disk/full capture sequences.

Replace the development libkrun and vm-memory Git patches with the
published msb_krun 0.1.34 family and msb-vm-memory 0.18.0-msb.2.
Update imago to 0.1.7 so disk and runtime code share one memory crate.
Retain the existing firmware pin and the #7 stack base.

Record release validation, 32 checkpoint and 39 snapshot regressions,
and the successful Mac live branch/restore/growth/compaction run.

Pipeline capture persistence with two writers and three reusable 32 MiB
packs. Reuse runtime-owned immutable RAM object receipts across captures
and batch directory durability before the existing root-last publication.

Pipeline eager restoration and cold memory backing construction with
bounded verified buffers. Seed root journals from unchanged admitted disk
files, retaining at most 32 file handles and hashing copied or rewritten
layers. Keep SDK payload verification unchanged.

Use one authoritative pause/resume mutation and validate its resulting
state. Combine cgroup notifications with bounded state rechecks so kernel
notification throttling cannot impose an avoidable 10 ms wait.

Preserve snapshot formats, dirty-baseline ordering, clock-before-thaw,
durability and failure cleanup. Add work counters and regression tests for
corruption, cancellation, concurrent writers and low descriptor budgets.

Extend --since exports to omit RAM objects supplied by the explicit
base alongside the physical disk prefix. Preserve complete memory maps
and CPU/device metadata, and resolve borrowed objects into owned staging
for both snapshot load and direct archive restore.

Keep --last-layers limited to disk selection. Update CLI/SDK documentation
and add malformed-input, corruption, retention and twelve-generation
archive regressions, plus a reproducible live qualification harness.

Validate 44 snapshot tests on both macOS and Linux and live twelve-step
chains for flat, layered and tmpfs roots with eager and forked restores.
Record timings and qualification limits in the smoke report.

BREAKING CHANGE: replace the unreleased disk-only archive dependency
encoding with msb-snapshot-dependencies-v1, without a compatibility shim.
Standalone archives and snapshot descriptors remain unchanged.

Admit operations through short-lived shared-handle locks so pending exec,
filesystem I/O and shutdown waits cannot block pause or resume. Preserve
consumed-handle rejection while admitted operations retain ownership.

Decode filesystem error envelopes before their payloads and propagate
paused-runtime diagnostics through unary and streaming operations.

Add ownership, cancellation and response-decoding tests, six live
concurrency cases on macOS and Linux, and the release timing report.
Both hosts passed all live cases and 137 Node unit tests; focused Rust
tests, TypeScript checks and native linting also passed.

Add group-scoped names and immutable member directories while preserving
portable snapshot identities across independent imports. Advance heads
only through known ancestry and retain concurrent sibling captures.

Carry source ancestry through capture, restore and local branch. Serialize
publication and retain cursor locks during cancellation. Expose group
selection and import options across the CLI and Rust, Python, Node and Go
SDKs. Update the path-keyed index, archive aliases and downgrade checks.

Cover group publication, duplicate imports, archive dependencies and
legacy artifact paths with automated tests and isolated macOS live
matrices for managed, flat and tmpfs roots.

BREAKING CHANGE: Bare snapshot names now select group heads. Address exact
members as group:member or use an explicit artifact path. Installed group
members cannot be overwritten with force.

Promote Branch & Snapshot with a fork icon and concise CLI examples.\nShow live branching and durable full snapshots in separate code groups.

Use app:saved to select the exact checkpoint under the source sandbox's
snapshot group, matching the current restore selector API.

Resolve disk and RAM dependencies across supplied archives and the
selected destination group, with an optional external base. Validate
complete owned closures before publishing members and select a group
head independently of archive order.

Expose batch loading through the CLI and Rust, Python, TypeScript, and
Go SDKs. Prefer .msb archive names throughout examples and documentation
without changing content-based decoding or archive schemas.

Record automated coverage and 102 macOS live command checks for full
and disk-only batches, including eager and forked restoration. Keep the
existing disk-only incremental-export limitation explicit.

BREAKING CHANGE: snapshot load takes one or more positional archives;
use --dest DIR instead of a positional destination directory.

Use --from-sandbox for snapshot capture, matching the existing SDK
source-sandbox naming. Update README, documentation, group examples,
and the branch, incremental, disk, and restore smoke scripts.

Test required source selection and rejection of --from, including
full capture, direct archives, and generated group members. All 13
snapshot parser tests pass.

BREAKING CHANGE: msb snapshot create requires --from-sandbox instead
of --from. No compatibility alias is provided.

Add a fast host-side snapshot/checkpoint test recipe and a bounded live
smoke suite for managed and flat disks. Cover branching, paused capture,
disk-only capture, grouped archive loading, eager/forked restore, and
source/child isolation. Verify runtime exit and reclaim successful test
homes while retaining reports and failure diagnostics.

Wire the smoke suite into Linux/KVM CI, document the commands, align
existing SDK/CLI tests with snapshot groups, and remove the extra
branching slogan from the README.

Merge the updated #7 parent into #8, preserving release transport,
runtime bootstrap, SDK lifecycle, and migration ordering. Record the
reviewed conflict resolutions without importing unrelated main changes.

Add bounded private freeze/thaw routing over the existing transport,
complete-frame capture barriers, retained input accounting, and restore
metadata validation. Keep generation 8 unchanged and replace only the
unreleased full-checkpoint contract. Preserve exact run ownership,
lineage publication, memory-cache pins, and failed-start cleanup.

Include focused regression tests, isolated live-test harnesses, and the
Mac/Linux qualification report. Native runtime and guest tests pass,
but retained-stdin control-credit starvation and mixed-load throughput
qualification remain open. This is a progress checkpoint, not a claim
that #8 is merge-ready.

Pin msb_krun and msb_krun_utils to the published 0.1.35 release and refresh only their matching lockfile entries.

Pick up runtime resolution of optional macOS GIC APIs without changing the snapshot format, guest protocol, or stack ancestry.

Keep stdio guard construction in the I/O error domain so the runtime spawn helper compiles on Windows. Own successful flag changes immediately and roll them back if a later handle update fails.

Add Windows regression tests for partial failure, duplicate handles and unchanged non-inheritable handles, and run them in both Windows CI jobs.

Account for Unix-only control-link parameters on Windows so the strict Clippy gate remains usable.

Separate retained input debt from metadata credit and allow bounded independent control progress without violating stream or lifecycle fences. Yield guest reads by actual work, preserve TCP half-close tails, and retain shared-memory payload ownership on combined transports.

Refresh maintenance clocks at transport admission, keep unrelated cleanup from fencing fresh commands, and strengthen source/child readiness checks under autonomous input pressure. Refuse incompatible unreleased transport barriers explicitly.

Validated the frozen patch with macOS and Linux live transport suites and benchmarks, plus protocol, guest, runtime and harness regression tests. Final stack integration with the newer registry dependency is checked separately.

Merge the updated immediate parent while retaining both Windows lifecycle-handoff and stdio-inheritance regression tests. Resolve the duplicate Windows endpoint-argument guard without changing its existing behavior.

Carry the release baseline, exact stack CI triggers and CI corrections forward. Formatting and diff checks pass; no unrelated main changes are included.

Merge the preserved transport fix commit onto the reconciled #8 branch. Its fourteen files are byte-for-byte identical to the macOS/Linux-qualified patch; retain the newer msb_krun 0.1.35 registry pin and both Windows test sets from the current stack.

Use the shared snapshot resolver from Python, retaining async not-found
errors and covering group, member, identity, directory and archive inputs.
Avoid the deprecated musl time_t alias without rounding freezer waits.
Use mirrored test images so registry authentication cannot hide regressions.

Integrate the reviewed parent fixes without changing branch, paused-source, or root-disk growth semantics. Carry source recovery diagnostics through final group and archive publication, and expose only confirmed artifact paths through the SDK errors.

Validate final group paths, head selection, ancestry cursors, artifact indexing, backend routing, and publication failures. The SDK suite passes 709 tests with two ignored; production Clippy and formatting pass.

Inherit the two parent binding lint fixes while retaining group-aware async snapshot resolution and unchanged Python keyword arguments. Final Python Clippy passes with warnings denied.

Keep the short /tmp default while allowing a separate short home parent on hosts with quota-limited tmpfs. Each test still creates its own isolated home and never borrows existing sandbox state.

Add a fixture regression for directory ownership and preserve the concurrent README update. All 34 transport harness unit tests pass.